#ifndef BASE_H
#define BASE_H
#include <memory>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <list>

#include "LinkControl.h"


void* operator new(size_t allocateBlock);

void operator delete(void* pMemory);

// 自定义的分配器
template <typename T>
struct KS_Allocator {
    using value_type = T;

    // 构造函数
    KS_Allocator() = default;

    // 复制构造函数
    template <typename U>
    KS_Allocator(const KS_Allocator<U>&) {}

    // 分配内存
    T* allocate(std::size_t n) {
        if (n == 0) {
            return nullptr;
        }
        void* ptr = nullptr;
        // 使用 KS_malloc 分配内存，注意第一个参数是指针的地址
        KS_malloc(&ptr, n * sizeof(T), 0);
        if (!ptr) {
            throw std::bad_alloc();
        }
        return static_cast<T*>(ptr);
    }

    // 释放内存
    void deallocate(T* p, std::size_t n) {
        // 使用 KS_free 释放内存，注意第二个参数是 0
        KS_free(p, 0);
    }

    template <typename U>
    struct rebind {
        using other = KS_Allocator<U>;
    };
};

// 定义自定义分配器的全局比较器
template <typename T, typename U>
bool operator==(const KS_Allocator<T>&, const KS_Allocator<U>&) {
    return true;
}

template <typename T, typename U>
bool operator!=(const KS_Allocator<T>&, const KS_Allocator<U>&) {
    return false;
}

// 自定义比较器
struct KS_Compare {
    template <typename T>
    bool operator()(const T& a, const T& b) const {
        return a < b;  // 默认的比较器是小于
    }
};

using KS_string = std::basic_string<char, std::char_traits<char>, KS_Allocator<char>>;

template <typename T>
using KS_vector = std::vector<T, KS_Allocator<T>>;

template <typename Key, typename T, typename Compare = KS_Compare>
using KS_map = std::map<Key, T, Compare, KS_Allocator<std::pair<const Key, T>>>;

template <typename Key, typename T, typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using KS_unordered_map = std::unordered_map<Key, T, Hash, KeyEqual, KS_Allocator<std::pair<const Key, T>>>;

// 自定义set
template <typename Key, typename Compare = KS_Compare>
using KS_set = std::set<Key, Compare, KS_Allocator<Key>>;

// 自定义list
template <typename T>
using KS_list = std::list<T, KS_Allocator<T>>;
#endif // BASE_H